home *** CD-ROM | disk | FTP | other *** search
/ Best of Shareware / Best of PC Windows Shareware 1.0 - Wayzata Technology (7111) (1993).iso / mac / ZIPPED / DOS / GRAPHICS / POVSRC.ZIP / MACHINE.ZIP / MAC.SIT / printf2window.c < prev    next >
Text File  |  1992-04-27  |  49KB  |  1,528 lines
  1. /*
  2. ==============================================================================
  3. Project:    POV-Ray
  4.  
  5. File Name:    printf2window.c
  6.  
  7. Description:
  8.     General-purpose printf-capturing routines that allow a console-like
  9.     output window for c programs that otherwise prefer to use printf/fprintf.
  10.     This code was "inspired heavily" from sources such as MacDTS'es TESample,
  11.     MacApp's Transcript window, and previous code of mine.  It is fairly well
  12.     self-contained, and works in MPW C 3.2 and Think C 5.0.
  13.  
  14.     This is the main source file, containing the private definitions and
  15.     code to implement all the needed external and internal support functions.
  16.  
  17. Related Files:
  18.     stdio_p2w.h        - generic header for sources that would otherwise use <stdio.h>
  19.     printf2window.h    - Mac-specific header for p2w routines
  20.     printf2window.c    - the main source for the p2w routines
  21. ------------------------------------------------------------------------------
  22. Author:
  23.     Eduard [esp] Schwan
  24. ------------------------------------------------------------------------------
  25. Copyright 1992 POV-Team.
  26.     This source code is distributed exclusively with POV, and is subject to
  27.     the same distribution restrictions as the rest of the source code.
  28.  
  29. *  Copying, distribution and legal info is in the file povlegal.doc which
  30. *  should be distributed with this file. If povlegal.doc is not available
  31. *  or for more information please contact:
  32. *
  33. *       Drew Wells [POV-Team Leader] 
  34. *       CIS: 73767,1244  Internet: 73767.1244@compuserve.com
  35. *       Phone: (213) 254-4041
  36. * 
  37.  
  38. ------------------------------------------------------------------------------
  39. Change History:
  40.     920318    [esp]    Created.
  41.     920325    [esp]    Added init/Terminate, major redesign of std c fns.
  42.     920327    [esp]    Robustized AddCString code that handles TERec-is-full delete logic
  43.     920329    [esp]    Added AdjustScrollBars call in AddCString to update scrollers as text is added
  44.     920330    [esp]    Updated file header with copyright & related files info
  45.     920401    [esp]    Added p2wSignature to window record for safety checking
  46.     920402    [esp]    Fixed cr/lf bug in bottleneck routine
  47.     920412    [esp]    Fixed potential integer overflow in comparison in AddCString routine
  48.     920412    [esp]    Added most function header comments, added windBounds support in Newp2wWindow, fixed scroller activate bug
  49.     920413    [esp]    Fixed misbehavin' scrollbars hilite upon activate/deactivate
  50. ==============================================================================
  51. */
  52.  
  53. /* Standard C library headers */
  54. #include <stdarg.h>        // ANSI C variable length argument support
  55. #include <string.h>        // strlen
  56.  
  57. /* Macintosh-specific headers */
  58. #include <Types.h>
  59. #include <Controls.h>
  60. #include <Dialogs.h>
  61. #include <Files.h>
  62. #include <Memory.h>
  63. #include <OSUtils.h>
  64. #include <Resources.h>
  65. #include <Windows.h>
  66. #ifdef _applec
  67. #include <strings.h>        /*p2cstr*/
  68. #endif
  69.  
  70. #include "printf2window.h"    /* our defs AND stdio.h for sprintf, etc. */
  71.  
  72.  
  73. // ==== Constant definitions
  74.  
  75. // Comment USE_P2W_RESOURCES out to create the window & controls from scratch..
  76. // Leave it in to create them from resources
  77.  
  78. #define    USE_P2W_RESOURCES    true
  79.  
  80.  
  81. // Resource IDs of supporting p2w resources
  82.  
  83. #ifdef USE_P2W_RESOURCES
  84. #define    kp2w_WindowID        9601
  85. #define    kp2w_VScrollID        9601
  86. #define    kp2w_HScrollID        9602
  87. #endif USE_P2W_RESOURCES
  88.  
  89.  
  90. // Magic p2w window record signature value
  91.  
  92. #define    kp2wWindowSignature    'p2w '
  93.  
  94.  
  95. // kTextMargin is the number of pixels we leave blank at the edge of the window.
  96.  
  97. #define kTextMargin                2
  98.  
  99.  
  100. // kControlInvisible is used to 'turn off' controls (i.e., cause the control not
  101. // to be redrawn as a result of some Control Manager call such as SetCtlValue)
  102. // by being put into the contrlVis field of the record. kControlVisible is used
  103. // the same way to 'turn on' the control.
  104.  
  105. #define kControlInvisible        0
  106. #define kControlVisible            0xFF
  107.  
  108.  
  109. // kControlHiliteActive is used to activate controls (contrlHilite)
  110. // kControlHiliteInactive is used to deactivate controls (contrlHilite)
  111.  
  112. #define kControlHiliteActive        0
  113. #define kControlHiliteInactive        0xFF
  114.  
  115.  
  116. // kButtonScroll is how many pixels to scroll horizontally when the button part
  117. // of the horizontal scrollbar is pressed.
  118.  
  119. #define kButtonScroll            4
  120.  
  121. // kScrollbarAdjust and kScrollbarWidth are used in calculating
  122. // values for control positioning and sizing.
  123.  
  124. #define kScrollbarWidth            16
  125. #define kScrollbarAdjust        (kScrollbarWidth - 1)
  126.  
  127.  
  128. // kScrollTweek compensates for off-by-one requirements of the scrollbars
  129. // to have borders coincide with the growbox.
  130.  
  131. #define kScrollTweek            2
  132.  
  133.  
  134. // kMaxTELength is an arbitrary number used to limit the length of text in the TERec
  135. // so that various errors won't occur from too many characters in the text.  When the
  136. // string to be added exceeds kMaxTELength, then strlen+kTEDeleteChunkSize
  137. // characters will be deleted from the beginning of the TERec.  This lets the TE
  138. // buffer stay pretty full while characters "fall off the top" of the buffer, and
  139. // insures that the performance delay of deleting from the front of the buffer
  140. // only happens every once in awhile, instead of for every single additional
  141. // string added.  kTEDeleteChunkSize should probably be between 1k and 20k..
  142.  
  143. #define    kMaxTELength            32700    // 32700 is pretty close to 32767, no?
  144. #define    kTEDeleteChunkSize        5000    // should be between 1000 and 20000
  145.  
  146.  
  147. // kMinDocSize is the smallest horiz/vert size of a grown window.
  148.  
  149. #define    kMinDocSize                100
  150.  
  151.  
  152. // kMaxStdIOBuffSize is the largest supported size of a single formatted
  153. // stdio C string.  Note that internally, a relocatable buffer of this size
  154. // will be allocated.
  155.  
  156. #define    kMaxStdIOBuffSize        1024
  157.  
  158.  
  159. // internal macro definitions
  160.  
  161. // Define some structure accessing macros for efficiency.
  162. #define GET_HIWORD(aLong)    (((aLong)>>16)&0x0FFFFL)
  163. #define GET_LOWORD(aLong)    ((aLong)&0x0FFFFL)
  164. #define GET_TOPLEFT_POINT(aRect)    (*(Point*)&(aRect).top)
  165. #define GET_BOTRIGHT_POINT(aRect)    (*(Point*)&(aRect).bottom)
  166. #define GET_RECT_WIDTH(aRect)        ((aRect).right - (aRect).left)
  167. #define GET_RECT_HEIGHT(aRect)        ((aRect).bottom - (aRect).top)
  168.  
  169. /*
  170. ----------------------------------
  171. prototypes for internal routines
  172. ----------------------------------
  173. */
  174.  
  175. static void p2wi_GetTERect(const p2w_WindowPtr thep2wWindow, Rect *teRect);
  176. static void p2wi_AdjustTE(const p2w_WindowPtr thep2wWindow);
  177. static void p2wi_AdjustViewRect(TEHandle p2wTE);
  178. static void p2wi_CommonAdjustScroller(const Boolean isVert, const p2w_WindowPtr thep2wWindow, ControlHandle control, TEHandle theTEHandle, const Boolean canRedraw);
  179. static void p2wi_AdjustScrollValues(const p2w_WindowPtr thep2wWindow, const Boolean doRedraw);
  180. static void p2wi_AdjustScrollSizes(const p2w_WindowPtr thep2wWindow);
  181. static void p2wi_AdjustScrollbars(const p2w_WindowPtr thep2wWindow, const Boolean doResize);
  182. static void p2wi_ResizeWindow(const p2w_WindowPtr thep2wWindow);
  183. static void p2wi_GetLocalUpdateRegion(const p2w_WindowPtr thep2wWindow, RgnHandle localRgn);
  184. static void p2wi_CommonScrollAction(ControlHandle control, short *amount);
  185. pascal void p2wi_VScrollActionProc(ControlHandle control, short part);
  186. pascal void p2wi_HScrollActionProc(ControlHandle control, short part);
  187. static int p2w_StdCOut_BottleNeck(const FILE *stream);
  188. static int p2w_vfprintf(FILE *stream, const char *format, va_list va_args);
  189.  
  190.  
  191.  
  192. /*
  193. ----------------------------------
  194. global variable definitions
  195. ----------------------------------
  196. */
  197.  
  198. static Handle            p2w_Stdio_OutBuf_Hdl = NULL;
  199. static p2w_WindowPtr    local_p2wWindow = NULL;
  200.  
  201.  
  202.  
  203. /*---------------------------------------------------------------------*/
  204. /*==== Main interface routines ====*/
  205.  
  206.  
  207. /*
  208. ******************************************************************************
  209. Name:
  210.     p2w_Init
  211. ------------------------------------------------------------------------------
  212. Purpose:
  213.     Primary (one-time) initialization of the p2w routines
  214. ------------------------------------------------------------------------------
  215. Description:
  216.     pre-allocates internal storage & initializes variables
  217. ------------------------------------------------------------------------------
  218. Parameters:
  219.     void
  220. ------------------------------------------------------------------------------
  221. When Used:
  222.     Called once, when the application starts up
  223. ******************************************************************************
  224. */
  225. OSErr p2w_Init(void)
  226. {
  227.     OSErr    anError = noErr;
  228.  
  229.     // allocate an output character stream buffer to use
  230.     p2w_Stdio_OutBuf_Hdl = NewHandle(kMaxStdIOBuffSize);
  231.     anError = MemError();
  232.     local_p2wWindow = NULL;
  233.  
  234.     return anError;
  235. } // p2w_Init
  236.  
  237.  
  238.  
  239. /*
  240. ******************************************************************************
  241. Name:
  242.     p2w_Terminate
  243. ------------------------------------------------------------------------------
  244. Purpose:
  245.     Primary (one-time) destruction of the p2w routines
  246. ------------------------------------------------------------------------------
  247. Description:
  248.     de-allocates internal storage & invalidates variables
  249. ------------------------------------------------------------------------------
  250. Parameters:
  251.     void
  252. ------------------------------------------------------------------------------
  253. When Used:
  254.     Called once, when the application is shutting down
  255. ******************************************************************************
  256. */
  257. OSErr p2w_Terminate(void)
  258. {
  259.     OSErr    anError = noErr;
  260.  
  261.     if (p2w_Stdio_OutBuf_Hdl)
  262.     {
  263.         DisposeHandle(p2w_Stdio_OutBuf_Hdl);
  264.         anError = MemError();
  265.     }
  266.     p2w_Stdio_OutBuf_Hdl = NULL;
  267.     local_p2wWindow = NULL;
  268.  
  269.     return anError;
  270. } // p2w_Terminate
  271.  
  272.  
  273.  
  274. /*
  275. ******************************************************************************
  276. Name:
  277.     p2w_NewWindow
  278. ------------------------------------------------------------------------------
  279. Purpose:
  280.     Creates a new p2w window structure for use by other p2w routines.
  281. ------------------------------------------------------------------------------
  282. Description:
  283.     Creates a p2w window (either from resources or from parameters),
  284.     initializes it, and shows it if asked.
  285. ------------------------------------------------------------------------------
  286. Parameters:
  287.     windBoundsPtr    Where to place the new window on the screen.
  288.                     If NULL, the resource bounds will be used.
  289.     windTitle        The Pascal title string to use for the new window.
  290.                     If NULL, resource title will be used.
  291.     windIsVisible    TRUE will show window after creation, FALSE will leave hidden.
  292.     windFont        Text Font to use for new window.
  293.     windFontSize    Text Font Size tose for new window.
  294.     anError            Returns any error code, or zero (noErr) if all went OK.
  295. ------------------------------------------------------------------------------
  296. When Used:
  297.     Called when a new p2w window needs to be allocated.  It may or may not
  298.     be shown at this time.  This call mainly creates the window structures.
  299. ******************************************************************************
  300. */
  301. p2w_WindowPtr p2w_NewWindow(const    Rect        *windBoundsPtr,
  302.                             const    Str255        windTitle,
  303.                             const    Boolean        windIsVisible,
  304.                             const    int            windFont,
  305.                             const    short        windFontSize,
  306.                                     OSErr        *anError)
  307. {
  308.     WindowPtr        aWindow;
  309.     Rect            destRect, viewRect, screenRect;
  310.     p2w_WindowPtr    p2wWPtr = NULL;
  311.     GrafPtr            savedPort;
  312.  
  313.     GetPort(&savedPort);    // I'll be back..
  314.  
  315.     /* how big is the screen */
  316.     screenRect = qd.screenBits.bounds;
  317.  
  318.     /* allocate space for our extended p2window record */
  319.     p2wWPtr = (p2w_WindowPtr)NewPtr(sizeof(p2w_WindowRecord));
  320.     *anError = MemError();
  321.     if (!*anError)
  322.     {
  323.         // initialize the p2w record
  324.  
  325.         p2wWPtr->p2wSignature        = kp2wWindowSignature; // bless this special window record
  326.         p2wWPtr->p2wOpenedOK        = false; // until actually opened later
  327.         p2wWPtr->p2wTEHandle        = NULL;
  328.         p2wWPtr->p2wVScroller        = NULL;
  329.         p2wWPtr->p2wHScroller        = NULL;
  330.         p2wWPtr->p2wClickHandler    = NULL;
  331.         p2wWPtr->p2wMaxDocWidth        = GET_RECT_WIDTH(screenRect) - kScrollbarWidth - 2*kTextMargin - 10;
  332.         p2wWPtr->p2wAlwaysScrollToBottom    = true;
  333.  
  334.         /* now create the Window */
  335. #ifdef USE_P2W_RESOURCES
  336.         aWindow = GetNewWindow(kp2w_WindowID, p2wWPtr, (WindowPtr)-1);
  337.         *anError = ResError();
  338. #else
  339.         aWindow = NewWindow(p2wWPtr, windBounds, windTitle, isVisible, documentProc, (WindowPtr)-1, hasGoAway, 0);
  340.         *anError = MemError();
  341. #endif USE_P2W_RESOURCES
  342.     }
  343.  
  344.     /* Move the window to user-specified position? */
  345.     if ((!*anError) && (windBoundsPtr != NULL))
  346.     {
  347.         MoveWindow(aWindow, (*windBoundsPtr).left, (*windBoundsPtr).top, false);
  348.         SizeWindow(aWindow, GET_RECT_WIDTH(*windBoundsPtr), GET_RECT_HEIGHT(*windBoundsPtr), false);
  349.     }
  350.  
  351.     if (!*anError)
  352.     {
  353.         p2wWPtr->p2wOpenedOK = true; // now its OK to call CloseWindow later..
  354.  
  355.         /* Set its title to what the user passed in, if non-null */
  356.         if (windTitle)                            // not a NULL pointer?
  357.             if (*windTitle)                        // not an empty string?
  358.                 SetWTitle(aWindow, windTitle);    // then do it!
  359.  
  360.         /* set up the font in the port */
  361.         SetPort(aWindow);
  362.         TextFont(windFont);
  363.         TextSize(windFontSize);
  364.  
  365.         /* set up the EditText buffer & area */
  366.         p2wi_GetTERect(p2wWPtr, &viewRect);
  367.         destRect = viewRect;
  368.         destRect.right = destRect.left + p2wWPtr->p2wMaxDocWidth;
  369.         p2wWPtr->p2wTEHandle = TENew(&destRect, &viewRect);
  370.         *anError = MemError();
  371.     }
  372.  
  373.     if (!*anError)
  374.     {
  375.         p2wi_AdjustViewRect(p2wWPtr->p2wTEHandle);
  376.         // turn on auto-scrolling
  377. //        TEAutoView(true, p2wWPtr->p2wTEHandle); -- later, when we auto-connect to scrollbars
  378.     }
  379.  
  380.     /* Create vertical scrollbar */
  381.     if (!*anError)
  382.     {
  383. #ifdef USE_P2W_RESOURCES
  384.         p2wWPtr->p2wVScroller = GetNewControl(kp2w_VScrollID, aWindow);
  385.         *anError = ResError();
  386. #else
  387.         p2wWPtr->p2wVScroller = NewControl(aWindow, aWindow^.portRect, "", false, 0, 0, 1, scrollBarProc, 0);
  388.         *anError = MemError();
  389. #endif USE_P2W_RESOURCES
  390.     }
  391.  
  392.     /* Create horizontal scrollbar */
  393.     if (!*anError)
  394.     {
  395. #ifdef USE_P2W_RESOURCES
  396.         p2wWPtr->p2wHScroller = GetNewControl(kp2w_HScrollID, aWindow);
  397.         *anError = ResError();
  398. #else
  399.         p2wWPtr->p2wHScroller = NewControl(aWindow, aWindow^.portRect, "", false, 0, 0, 1, scrollBarProc, 0);
  400.         *anError = MemError();
  401. #endif USE_P2W_RESOURCES
  402.     }
  403.  
  404.     // adjust & draw the controls, draw the window
  405.     if (!*anError)
  406.     {
  407.         p2wi_AdjustScrollbars(p2wWPtr, true/*kResize*/);
  408.         if (windIsVisible)
  409.             ShowWindow(aWindow);
  410.     }
  411.  
  412.     // Return to port after storm
  413.     SetPort(savedPort);    // I'm back..
  414.  
  415.     // close & dispose if any errors happened!
  416.     if (*anError)
  417.     {
  418.         p2w_DisposeWindow(p2wWPtr);
  419.         // if errors happened, don't give user any pointers
  420.         p2wWPtr = NULL;
  421.     }
  422.  
  423.     // remember this for the StdIO routines later..
  424.     local_p2wWindow = p2wWPtr;
  425.  
  426.     return (p2wWPtr);
  427.  
  428. } // p2w_NewWindow
  429.  
  430.  
  431.  
  432. /*
  433. ******************************************************************************
  434. Name:
  435.     p2w_DisposeWindow
  436. ------------------------------------------------------------------------------
  437. Purpose:
  438.     Deletes an existing p2w window structure and its related TE danglies.
  439. ------------------------------------------------------------------------------
  440. Description:
  441.     Disposes of the TE record, closes the window/grafport, and disposes
  442.     of the window/grafport itself.
  443. ------------------------------------------------------------------------------
  444. Parameters:
  445.     the_p2wPtr        The p2w window to dispose.
  446. ------------------------------------------------------------------------------
  447. When Used:
  448.     Called when a p2w window is no longer needed.
  449. ******************************************************************************
  450. */
  451. void p2w_DisposeWindow(p2w_WindowPtr the_p2wPtr)
  452. {
  453.     // Is the window pointer not null?
  454.     if (the_p2wPtr)
  455.         // is this really one of our p2w windows?
  456.         // (We don't want to dispose extra stuff if it's really
  457.         // a normal [sheep] WindowPtr passed in as a [wolf] p2w_WindowPtr!)
  458.         if (the_p2wPtr->p2wSignature == kp2wWindowSignature)
  459.         {
  460.             // Dispose Window/GrafPort danglies if opened ok
  461.             if (the_p2wPtr->p2wOpenedOK)
  462.                 CloseWindow((WindowPtr)the_p2wPtr);
  463.             // Dispose of our TE Record
  464.             if (the_p2wPtr->p2wTEHandle)
  465.                 TEDispose(the_p2wPtr->p2wTEHandle);
  466.             // set fields back to nil, to help catch anyone touching them after dispose!
  467.             the_p2wPtr->p2wOpenedOK        = false;
  468.             the_p2wPtr->p2wTEHandle        = NULL;
  469.             the_p2wPtr->p2wVScroller    = NULL;
  470.             the_p2wPtr->p2wHScroller    = NULL;
  471.             the_p2wPtr->p2wClickHandler    = NULL;
  472.             // Dispose our version of window record itself now
  473.             DisposePtr((Ptr)the_p2wPtr);
  474.             local_p2wWindow = NULL;
  475.         }
  476. } // p2w_DisposeWindow
  477.  
  478.  
  479. /*
  480. ******************************************************************************
  481. Name:
  482.     p2w_AddCString
  483. ------------------------------------------------------------------------------
  484. Purpose:
  485.     Adds the text in the C-style string passed to the p2w window.
  486. ------------------------------------------------------------------------------
  487. Description:
  488. ------------------------------------------------------------------------------
  489. Parameters:
  490.     the_p2wPtr        The p2w window to add to.
  491.     theCStrPtr        The string of text to add.
  492.     p2w_AddCString    function returns zero if ok, or an error #.
  493. ------------------------------------------------------------------------------
  494. When Used:
  495.     Called when text is to be added to the p2w window.
  496. ******************************************************************************
  497. */
  498. OSErr p2w_AddCString(p2w_WindowPtr the_p2wPtr, const char * theCStrPtr)
  499. {
  500.     OSErr    anError = noErr;
  501.     long    theStrLen;
  502.  
  503.     if (the_p2wPtr && theCStrPtr)        // if window and string ptrs are valid
  504.         // is this really one of our p2w windows?
  505.         // (We don't want to fiddle with extra stuff if it's really
  506.         // a normal [sheep] WindowPtr passed in as a [wolf] p2w_WindowPtr!)
  507.         if (the_p2wPtr->p2wSignature == kp2wWindowSignature)
  508.             if (the_p2wPtr->p2wTEHandle)
  509.             {    // TE Record is valid
  510.                 theStrLen = strlen(theCStrPtr);
  511.                 if (theStrLen > 0)    // if string is not empty, add it
  512.                 {
  513.                     // If TE is too full, need to delete some at beginning before adding
  514.                     // (this looks weird, but it is the Mathematically Correct way to
  515.                     // compare numbers close to the edge of 32767-land.. note that
  516.                     // teLength+theStrLen could overflow, so we subtract instead.)
  517.                     if ((**(the_p2wPtr->p2wTEHandle)).teLength > (kMaxTELength - theStrLen))
  518.                     {
  519.                         // Delete some text at beginning of TE
  520.                         TESetSelect(0, theStrLen+kTEDeleteChunkSize, the_p2wPtr->p2wTEHandle);
  521.                         TEDelete(the_p2wPtr->p2wTEHandle);
  522.                     }
  523.                     // go to very end of TE (-1 is really +65535 in TE Worlds!)
  524.                     TESetSelect(-1, -1, the_p2wPtr->p2wTEHandle);
  525.                     // stick it in there
  526.                     TEInsert(theCStrPtr, theStrLen, the_p2wPtr->p2wTEHandle);
  527.                     // re-draw the scrollbars, since they may have changed
  528.                     p2wi_AdjustScrollbars(the_p2wPtr, true/*kRedraw*/);
  529.                 }    // theStrLen > 0
  530.             }    // TE Record is valid
  531.     return(anError);
  532. } // p2w_AddCString
  533.  
  534.  
  535. /*
  536. ******************************************************************************
  537. Name:
  538.     p2w_DrawWindow
  539. ------------------------------------------------------------------------------
  540. Purpose:
  541.     Draw the contents of an application window.
  542. ------------------------------------------------------------------------------
  543. Description:
  544.     
  545. ------------------------------------------------------------------------------
  546. Parameters:
  547.     
  548. ------------------------------------------------------------------------------
  549. When Used:
  550.     
  551. ******************************************************************************
  552. */
  553. void p2w_DrawWindow(const p2w_WindowPtr the_p2wPtr)
  554. {
  555.     // move in for the kill
  556.     SetPort((WindowPtr)the_p2wPtr);
  557.     // kill off old bits
  558.     EraseRect(&((WindowPtr)the_p2wPtr)->portRect);
  559.     // regain controls
  560.     DrawGrowIcon((WindowPtr)the_p2wPtr);
  561.     DrawControls((WindowPtr)the_p2wPtr);
  562.     // show them our text
  563.     TEUpdate(&((WindowPtr)the_p2wPtr)->portRect, the_p2wPtr->p2wTEHandle);
  564. } // p2w_DrawWindow
  565.  
  566.  
  567.  
  568. /*
  569. ******************************************************************************
  570. Name:
  571.     p2w_DoUpdate
  572. ------------------------------------------------------------------------------
  573. Purpose:
  574.     Update (redraw) the contents of an application window.
  575. ------------------------------------------------------------------------------
  576. Description:
  577.     
  578. ------------------------------------------------------------------------------
  579. Parameters:
  580.     
  581. ------------------------------------------------------------------------------
  582. When Used:
  583.     
  584. ******************************************************************************
  585. */
  586. void p2w_DoUpdate(const p2w_WindowPtr thep2wWindow)
  587. {
  588.     // move in for the kill
  589.     SetPort((WindowPtr)thep2wWindow);
  590.     BeginUpdate((WindowPtr)thep2wWindow);                /* this sets up the visRgn */
  591.     if (!EmptyRgn(((WindowPtr)thep2wWindow)->visRgn))    /* draw if updating needs to be done */
  592.         p2w_DrawWindow(thep2wWindow);
  593.     EndUpdate((WindowPtr)thep2wWindow);
  594. } // p2w_DoUpdate
  595.  
  596.  
  597. /*
  598. ******************************************************************************
  599. Name:
  600.     p2w_DoActivate
  601. ------------------------------------------------------------------------------
  602. Purpose:
  603.     This is called when a window is activated or deactivated.
  604.     It calls TextEdit to handle the selection.
  605. ------------------------------------------------------------------------------
  606. Description:
  607.     
  608. ------------------------------------------------------------------------------
  609. Parameters:
  610.     
  611. ------------------------------------------------------------------------------
  612. When Used:
  613.     
  614. ******************************************************************************
  615. */
  616. void p2w_DoActivate(const p2w_WindowPtr thep2wWindow, Boolean becomingActive)
  617. {
  618.     RgnHandle    tempRgn, clipRgn;
  619.  
  620.     /* move in for the kill */
  621.     SetPort((WindowPtr)thep2wWindow);
  622.  
  623.     /* the growbox should be changed immediately */
  624.     DrawGrowIcon((WindowPtr)thep2wWindow);
  625.  
  626.     if (becomingActive)
  627.     {
  628.         /*
  629.         since we don╒t want TEActivate to draw a selection in an area where we╒re
  630.         going to erase and redraw, we╒ll clip out the update region before calling it.
  631.         */
  632.         tempRgn = NewRgn();
  633.         clipRgn = NewRgn();
  634.         if (tempRgn && clipRgn)
  635.         {
  636.             p2wi_GetLocalUpdateRegion(thep2wWindow, tempRgn);    /* get localized update region */
  637.             GetClip(clipRgn);
  638.             DiffRgn(clipRgn, tempRgn, tempRgn);        /* subtract updateRgn from clipRgn */
  639.             SetClip(tempRgn);
  640.             TEActivate(thep2wWindow->p2wTEHandle);
  641.             SetClip(clipRgn);                        /* restore the full-blown clipRgn */
  642.             DisposeRgn(tempRgn);
  643.             DisposeRgn(clipRgn);
  644.         }
  645.  
  646.         /* the controls must be redrawn on activation */
  647.         ShowControl(thep2wWindow->p2wVScroller);
  648.         ShowControl(thep2wWindow->p2wHScroller);
  649.     }
  650.     else
  651.     {    /* De-Activating.. */
  652.         TEDeactivate(thep2wWindow->p2wTEHandle);
  653.  
  654.         /* the controls must be hidden on deactivation */
  655.         HideControl(thep2wWindow->p2wVScroller);
  656.         HideControl(thep2wWindow->p2wHScroller);
  657.     }
  658. } // p2w_DoActivate
  659.  
  660.  
  661. /*
  662. ******************************************************************************
  663. Name:
  664.     p2w_DoGrow
  665. ------------------------------------------------------------------------------
  666. Purpose:
  667.     Called when a mouseDown occurs in the grow box of an active
  668.     window. In order to eliminate any 'flicker', we want to
  669.     invalidate only what is necessary. Since p2w_ResizeWindow
  670.     invalidates the whole portRect, we save the old TE
  671.     viewRect, intersect it with the new TE viewRect, and remove
  672.     the result from the update region. However, we must make
  673.     sure that any old update region that might have been around
  674.     gets put back. 
  675. ------------------------------------------------------------------------------
  676. Description:
  677.     
  678. ------------------------------------------------------------------------------
  679. Parameters:
  680.     
  681. ------------------------------------------------------------------------------
  682. When Used:
  683.     
  684. ******************************************************************************
  685. */
  686. void p2w_DoGrow(const p2w_WindowPtr thep2wWindow, EventRecord *theEvent)
  687. {
  688.     long        growResult;
  689.     Rect        tempRect;
  690.     RgnHandle    tempRgn;
  691.     
  692.     // move in for the kill
  693.     SetPort((WindowPtr)thep2wWindow);
  694.  
  695.     /* set up limiting values */
  696.     tempRect = qd.screenBits.bounds;
  697.     tempRect.left = kMinDocSize;
  698.     tempRect.top = kMinDocSize;
  699.  
  700.     growResult = GrowWindow((WindowPtr)thep2wWindow, theEvent->where, &tempRect);
  701.     /* see if it really changed size */
  702.     if (growResult != 0)
  703.     {
  704.         tempRect = (**thep2wWindow->p2wTEHandle).viewRect;    /* save old text box */
  705.         tempRgn = NewRgn();
  706.         p2wi_GetLocalUpdateRegion(thep2wWindow, tempRgn);        /* get localized update region */
  707.         SizeWindow((WindowPtr)thep2wWindow, GET_LOWORD(growResult), GET_HIWORD(growResult), true);
  708.         p2wi_ResizeWindow(thep2wWindow);
  709.  
  710.         /* calculate & validate the region that hasn╒t changed, so it won╒t get redrawn */
  711.         SectRect(&tempRect, &(**thep2wWindow->p2wTEHandle).viewRect, &tempRect);
  712.         ValidRect(&tempRect);                            /* take it out of update */
  713.         InvalRgn(tempRgn);                                /* put back any prior update */
  714.         DisposeRgn(tempRgn);
  715.     }
  716. } // p2w_DoGrow
  717.  
  718.  
  719. /*
  720. ******************************************************************************
  721. Name:
  722.     p2w_DoZoom
  723. ------------------------------------------------------------------------------
  724. Purpose:
  725.     Called when a mouseClick occurs in the zoom box of an active
  726.     window. Everything has to get re-drawn here, so we don't mind
  727.     that p2w_ResizeWindow invalidates the whole portRect. 
  728. ------------------------------------------------------------------------------
  729. Description:
  730.     
  731. ------------------------------------------------------------------------------
  732. Parameters:
  733.     
  734. ------------------------------------------------------------------------------
  735. When Used:
  736.     
  737. ******************************************************************************
  738. */
  739. void p2w_DoZoom(const p2w_WindowPtr thep2wWindow, short part)
  740. {
  741.     EraseRect(&((WindowPtr)thep2wWindow)->portRect);
  742.     ZoomWindow((WindowPtr)thep2wWindow, part, (WindowPtr)thep2wWindow==FrontWindow());
  743.     p2wi_ResizeWindow(thep2wWindow);
  744. } // p2w_DoZoom
  745.  
  746.  
  747. /*
  748. ******************************************************************************
  749. Name:
  750.     p2w_DoContentClick
  751. ------------------------------------------------------------------------------
  752. Purpose:
  753.     This is called when a mouseDown occurs in the content of a window.
  754. ------------------------------------------------------------------------------
  755. Description:
  756.     
  757. ------------------------------------------------------------------------------
  758. Parameters:
  759.     
  760. ------------------------------------------------------------------------------
  761. When Used:
  762.     
  763. ******************************************************************************
  764. */
  765. void p2w_DoContentClick(const p2w_WindowPtr thep2wWindow, EventRecord *theEvent)
  766. {
  767.     Point        mouse;
  768.     ControlHandle control;
  769.     short        part, value;
  770.     Boolean        shiftDown;
  771.     Rect        teRect;
  772.  
  773.     SetPort((WindowPtr)thep2wWindow);
  774.  
  775.     /* get the click position */
  776.     mouse = theEvent->where;
  777.     GlobalToLocal(&mouse);
  778.  
  779.     /* see if we are in the viewRect. if so, we won╒t check the controls */
  780.     p2wi_GetTERect(thep2wWindow, &teRect);
  781.     if (PtInRect(mouse, &teRect))
  782.     {
  783.         /* see if we need to extend the selection */
  784.         shiftDown = (theEvent->modifiers & shiftKey) != 0;    /* extend if Shift is down */
  785.         TEClick(mouse, shiftDown, thep2wWindow->p2wTEHandle);
  786.     }
  787.     else
  788.     {
  789.         part = FindControl(mouse, (WindowPtr)thep2wWindow, &control);
  790.         switch (part)
  791.         {
  792.             case 0:        /* do nothing.. */
  793.                 break;
  794.             case inThumb:
  795.                 value = GetCtlValue(control);
  796.                 part = TrackControl(control, mouse, nil);
  797.                 if (part != 0)
  798.                 {
  799.                     value -= GetCtlValue(control);
  800.                     /* value now has CHANGE in value; if value changed, scroll */
  801.                     if (value != 0)
  802.                         if (control == thep2wWindow->p2wVScroller)
  803.                             TEScroll(0, value * (*thep2wWindow->p2wTEHandle)->lineHeight, thep2wWindow->p2wTEHandle);
  804.                         else
  805.                             TEScroll(value, 0, thep2wWindow->p2wTEHandle);
  806.                 }
  807.                 break;
  808.             default:    /* they clicked in an arrow, so track & scroll */
  809.                 if (control == thep2wWindow->p2wVScroller)
  810.                     value = TrackControl(control, mouse, (ProcPtr) p2wi_VScrollActionProc);
  811.                 else
  812.                 if (control == thep2wWindow->p2wHScroller)
  813.                     value = TrackControl(control, mouse, (ProcPtr) p2wi_HScrollActionProc);
  814.                 break;
  815.         }
  816.     }
  817. } // p2w_DoContentClick
  818.  
  819.  
  820.  
  821. /*---------------------------------------------------------------------*/
  822. /*==== Private internal p2w routines ====*/
  823.     
  824. /*
  825. ******************************************************************************
  826. Name:
  827.     p2wi_GetTERect
  828. ------------------------------------------------------------------------------
  829. Purpose:
  830.     Return a rectangle that is inset from the portRect by the
  831.     size of the scrollbars, plus a bit.
  832. ------------------------------------------------------------------------------
  833. Description:
  834.     
  835. ------------------------------------------------------------------------------
  836. Parameters:
  837.     
  838. ------------------------------------------------------------------------------
  839. When Used:
  840.     
  841. ******************************************************************************
  842. */
  843. static void p2wi_GetTERect(const p2w_WindowPtr thep2wWindow, Rect *teRect)
  844. {
  845.     *teRect = ((WindowPtr)thep2wWindow)->portRect;
  846.     InsetRect(teRect, kTextMargin, kTextMargin);    /* adjust for margin */
  847.     teRect->bottom = teRect->bottom - 15;        /* and for the scrollbars */
  848.     teRect->right = teRect->right - 15;
  849. } // p2wi_GetTERect
  850.  
  851.  
  852. /*
  853. ******************************************************************************
  854. Name:
  855.     p2wi_AdjustTE
  856. ------------------------------------------------------------------------------
  857. Purpose:
  858.     Scroll the TERec around to match up to the potentially updated scrollbar
  859.     values. This is really useful when the window has been resized such that
  860.     the scrollbars became inactive but the TERec was already scrolled.
  861. ------------------------------------------------------------------------------
  862. Description:
  863.     
  864. ------------------------------------------------------------------------------
  865. Parameters:
  866.     
  867. ------------------------------------------------------------------------------
  868. When Used:
  869.     
  870. ******************************************************************************
  871. */
  872. static void p2wi_AdjustTE(const p2w_WindowPtr thep2wWindow)
  873. {
  874.     short        hVal,vVal;
  875.     TEPtr        te;
  876.     
  877.     vVal = GetCtlValue(thep2wWindow->p2wVScroller);
  878.     hVal = GetCtlValue(thep2wWindow->p2wHScroller);
  879.     te = *thep2wWindow->p2wTEHandle;
  880.     TEScroll((te->viewRect.left - te->destRect.left) - hVal,
  881.             (te->viewRect.top - te->destRect.top) - (vVal * te->lineHeight),
  882.             thep2wWindow->p2wTEHandle);
  883. } // p2wi_AdjustTE
  884.  
  885.  
  886. /*
  887. ******************************************************************************
  888. Name:
  889.     p2wi_AdjustViewRect
  890. ------------------------------------------------------------------------------
  891. Purpose:
  892.     Update our TE view rect so it's the greatest multiple of
  893.     the lineHeight that still fits in the old viewRect.
  894. ------------------------------------------------------------------------------
  895. Description:
  896.     
  897. ------------------------------------------------------------------------------
  898. Parameters:
  899.     
  900. ------------------------------------------------------------------------------
  901. When Used:
  902.     
  903. ******************************************************************************
  904. */
  905. static void p2wi_AdjustViewRect(TEHandle p2wTE)
  906. {
  907.     TEPtr        te;
  908.     
  909.     te = *p2wTE;
  910.     te->viewRect.bottom = (((te->viewRect.bottom - te->viewRect.top) / te->lineHeight)
  911.                             * te->lineHeight) + te->viewRect.top;
  912. } // p2wi_AdjustViewRect
  913.  
  914.  
  915. /*
  916. ******************************************************************************
  917. Name:
  918.     p2wi_CommonAdjustScroller
  919. ------------------------------------------------------------------------------
  920. Purpose:
  921.     Calculate the new control maximum value and current value,
  922.     for the horizontal or vertical scrollbar. The vertical max
  923.     is calculated by comparing the number of lines to the
  924.     vertical size of the viewRect. The horizontal max is
  925.     calculated by comparing the maximum document width to the
  926.     width of the viewRect. The current values are set by
  927.     comparing the offset between the view and destination
  928.     rects. If necessary and we canRedraw, have the control be
  929.     re-drawn by calling ShowControl. 
  930. ------------------------------------------------------------------------------
  931. Description:
  932.     
  933. ------------------------------------------------------------------------------
  934. Parameters:
  935.     
  936. ------------------------------------------------------------------------------
  937. When Used:
  938.     Called by p2wi_AdjustScrollValues, twice.
  939. ******************************************************************************
  940. */
  941. static void p2wi_CommonAdjustScroller(const Boolean isVert, const p2w_WindowPtr thep2wWindow, ControlHandle control, TEHandle theTEHandle, const Boolean canRedraw)
  942. {
  943.     short        value, lines, max;
  944.     short        oldValue, oldMax;
  945.     
  946.     oldValue = GetCtlValue(control);
  947.     oldMax = GetCtlMax(control);
  948.     if (isVert)
  949.     {
  950.         lines = (**theTEHandle).nLines;
  951.         /* since nLines isn╒t right if the last character is a return, check for that case */
  952.         if ( *(*(**theTEHandle).hText + (**theTEHandle).teLength - 1) == '\r')
  953.             lines += 1;
  954.         max = lines - (((**theTEHandle).viewRect.bottom - (**theTEHandle).viewRect.top) / (**theTEHandle).lineHeight);
  955.     }
  956.     else
  957.         max = thep2wWindow->p2wMaxDocWidth - ((**theTEHandle).viewRect.right - (**theTEHandle).viewRect.left);
  958.     
  959.     if (max < 0)
  960.         max = 0;
  961.     SetCtlMax(control, max);
  962.     
  963.     if (isVert)
  964.     {
  965.         // always scroll to end?
  966.         if (thep2wWindow->p2wAlwaysScrollToBottom)
  967.             value = max;
  968.         else
  969.             value = ((**theTEHandle).viewRect.top - (**theTEHandle).destRect.top) / (**theTEHandle).lineHeight;
  970.     }
  971.     else
  972.         value = (**theTEHandle).viewRect.left - (**theTEHandle).destRect.left;
  973.     
  974.     if ( value < 0 )
  975.         value = 0;
  976.     else
  977.         if (value >  max)
  978.             value = max;
  979.     
  980.     SetCtlValue(control, value);
  981.  
  982.     /* now redraw the control if it needs to be and can be */
  983.     if (canRedraw || (max != oldMax) || (value != oldValue))
  984.     {
  985. //        InvalRect(&(**control).contrlRect);
  986.         Draw1Control(control);
  987.     }
  988. } // p2wi_CommonAdjustScroller
  989.  
  990.  
  991. /*
  992. ******************************************************************************
  993. Name:
  994.     p2wi_AdjustScrollValues
  995. ------------------------------------------------------------------------------
  996. Purpose:
  997.     Simply call the common adjust routine for both the vertical
  998.     and horizontal scrollbars.
  999. ------------------------------------------------------------------------------
  1000. Description:
  1001.     
  1002. ------------------------------------------------------------------------------
  1003. Parameters:
  1004.     
  1005. ------------------------------------------------------------------------------
  1006. When Used:
  1007.     
  1008. ******************************************************************************
  1009. */
  1010. static void p2wi_AdjustScrollValues(const p2w_WindowPtr thep2wWindow, const Boolean doRedraw)
  1011. {
  1012.     p2wi_CommonAdjustScroller(true, thep2wWindow, thep2wWindow->p2wVScroller, thep2wWindow->p2wTEHandle, doRedraw);
  1013.     p2wi_CommonAdjustScroller(false, thep2wWindow, thep2wWindow->p2wHScroller, thep2wWindow->p2wTEHandle, doRedraw);
  1014. } // p2wi_AdjustScrollValues
  1015.  
  1016.  
  1017.  
  1018. /*
  1019. ******************************************************************************
  1020. Name:
  1021.     p2wi_AdjustScrollSizes
  1022. ------------------------------------------------------------------------------
  1023. Purpose:
  1024.     Re-calculate the position and size of the viewRect and the
  1025.     scrollbars. The constant kScrollTweek compensates for the
  1026.     "off-by-one" requirements of the scrollbars that need their
  1027.     borders coinciding with the growbox. 
  1028. ------------------------------------------------------------------------------
  1029. Description:
  1030.     
  1031. ------------------------------------------------------------------------------
  1032. Parameters:
  1033.     
  1034. ------------------------------------------------------------------------------
  1035. When Used:
  1036.     
  1037. ******************************************************************************
  1038. */
  1039. static void p2wi_AdjustScrollSizes(const p2w_WindowPtr thep2wWindow)
  1040. {
  1041.     Rect        teRect;
  1042.     p2wi_GetTERect(thep2wWindow, &teRect);    // start with TERect..
  1043.     (*thep2wWindow->p2wTEHandle)->viewRect = teRect;
  1044.     p2wi_AdjustViewRect(thep2wWindow->p2wTEHandle);    /* snap to nearest line */
  1045.  
  1046.     /* Vertical */
  1047.     MoveControl(thep2wWindow->p2wVScroller,
  1048.                 ((WindowPtr)thep2wWindow)->portRect.right - kScrollbarAdjust,
  1049.                 -1);
  1050.     SizeControl(thep2wWindow->p2wVScroller,
  1051.                 kScrollbarWidth,
  1052.                 (((WindowPtr)thep2wWindow)->portRect.bottom
  1053.                     - ((WindowPtr)thep2wWindow)->portRect.top)
  1054.                     - (kScrollbarAdjust - kScrollTweek));
  1055.  
  1056.     /* Horizontal */
  1057.     MoveControl(thep2wWindow->p2wHScroller,
  1058.                 -1,
  1059.                 ((WindowPtr)thep2wWindow)->portRect.bottom - kScrollbarAdjust);
  1060.     SizeControl(thep2wWindow->p2wHScroller,
  1061.                 (((WindowPtr)thep2wWindow)->portRect.right
  1062.                     - ((WindowPtr)thep2wWindow)->portRect.left)
  1063.                     - (kScrollbarAdjust - kScrollTweek),
  1064.                 kScrollbarWidth);
  1065. } // p2wi_AdjustScrollSizes
  1066.  
  1067.  
  1068. /*
  1069. ******************************************************************************
  1070. Name:
  1071.     p2wi_AdjustScrollbars
  1072. ------------------------------------------------------------------------------
  1073. Purpose:
  1074.     Recalculate the scrollbar pos/values, and redraw if need be.
  1075. ------------------------------------------------------------------------------
  1076. Description:
  1077.     Turn off the controls by jamming a zero into their contrlVis fields
  1078.     (HideControl erases them and we don't want that). If the controls
  1079.     are to be resized as well, call the procedure to do that, then call
  1080.     the procedure to adjust the maximum and current values. Finally,
  1081.     re-enable the controls by jamming a $FF in their contrlVis fields.  
  1082. ------------------------------------------------------------------------------
  1083. Parameters:
  1084.     
  1085. ------------------------------------------------------------------------------
  1086. When Used:
  1087.     
  1088. ******************************************************************************
  1089. */
  1090. static void p2wi_AdjustScrollbars(const p2w_WindowPtr thep2wWindow, const Boolean doResize)
  1091. {
  1092.     short    oldHvis, oldVvis;
  1093.  
  1094.     oldVvis = (**thep2wWindow->p2wVScroller).contrlVis;
  1095.     oldHvis = (**thep2wWindow->p2wHScroller).contrlVis;
  1096.  
  1097.     /* First, turn visibility of scrollbars off to eliminate unwanted redrawing */
  1098.     (*thep2wWindow->p2wVScroller)->contrlVis = kControlInvisible;    /* turn them off */
  1099.     (*thep2wWindow->p2wHScroller)->contrlVis = kControlInvisible;
  1100.  
  1101.     /* move & size as needed */
  1102.     if (doResize)
  1103.         p2wi_AdjustScrollSizes(thep2wWindow);
  1104.  
  1105.     /* adjust constrols' max and current values */
  1106.     p2wi_AdjustScrollValues(thep2wWindow, doResize);
  1107.  
  1108.     /* now scroll the TE record to match the scrollbars */
  1109.     p2wi_AdjustTE(thep2wWindow);
  1110.  
  1111.     /* Now, restore visibility in case we never had to ShowControl during adjustment */
  1112.     (*thep2wWindow->p2wVScroller)->contrlVis = oldVvis;    /* restore them */
  1113.     (*thep2wWindow->p2wHScroller)->contrlVis = oldHvis;
  1114. } // p2wi_AdjustScrollbars
  1115.  
  1116.  
  1117. /*
  1118. ******************************************************************************
  1119. Name:
  1120.     p2wi_ResizeWindow
  1121. ------------------------------------------------------------------------------
  1122. Purpose:
  1123.     Called when the window has been resized to fix up the controls and content.
  1124. ------------------------------------------------------------------------------
  1125. Description:
  1126.     
  1127. ------------------------------------------------------------------------------
  1128. Parameters:
  1129.     
  1130. ------------------------------------------------------------------------------
  1131. When Used:
  1132.     
  1133. ******************************************************************************
  1134. */
  1135. static void p2wi_ResizeWindow(const p2w_WindowPtr thep2wWindow)
  1136. {
  1137.     p2wi_AdjustScrollbars(thep2wWindow, true);
  1138.     InvalRect(&((WindowPtr)thep2wWindow)->portRect);
  1139. } // p2wi_ResizeWindow
  1140.  
  1141.  
  1142.  
  1143. /*
  1144. ******************************************************************************
  1145. Name:
  1146.     p2wi_GetLocalUpdateRegion
  1147. ------------------------------------------------------------------------------
  1148. Purpose:
  1149.     Returns the update region in local coordinates
  1150. ------------------------------------------------------------------------------
  1151. Description:
  1152.     
  1153. ------------------------------------------------------------------------------
  1154. Parameters:
  1155.     
  1156. ------------------------------------------------------------------------------
  1157. When Used:
  1158.     
  1159. ******************************************************************************
  1160. */
  1161. static void p2wi_GetLocalUpdateRegion(const p2w_WindowPtr thep2wWindow, RgnHandle localRgn)
  1162. {
  1163.     CopyRgn(((WindowPeek)thep2wWindow)->updateRgn, localRgn);    /* save old update region */
  1164.     OffsetRgn(localRgn, ((WindowPtr)thep2wWindow)->portBits.bounds.left,
  1165.                         ((WindowPtr)thep2wWindow)->portBits.bounds.top);
  1166. } // p2wi_GetLocalUpdateRegion
  1167.  
  1168.  
  1169.  
  1170. /*
  1171. ******************************************************************************
  1172. Name:
  1173.     p2wi_CommonScrollAction
  1174. ------------------------------------------------------------------------------
  1175. Purpose:
  1176.     Common algorithm for pinning the value of a control. It
  1177.     returns the actual amount the value of the control changed.
  1178.     Note the pinning is done for the sake of returning the
  1179.     amount the control value changed.
  1180. ------------------------------------------------------------------------------
  1181. Description:
  1182.     
  1183. ------------------------------------------------------------------------------
  1184. Parameters:
  1185.     
  1186. ------------------------------------------------------------------------------
  1187. When Used:
  1188.     Called by p2wi_HScrollActionProc, p2wi_VScrollActionProc
  1189. ******************************************************************************
  1190. */
  1191. static void p2wi_CommonScrollAction(ControlHandle control, short *amount)
  1192. {
  1193.     short        value, max;
  1194.     
  1195.     /* get the current value.. */
  1196.     value = GetCtlValue(control);
  1197.  
  1198.     /* and the biggest value */
  1199.     max = GetCtlMax(control);
  1200.  
  1201.     *amount = value - *amount;
  1202.     if ( *amount < 0 )
  1203.         *amount = 0;
  1204.     else if ( *amount > max )
  1205.         *amount = max;
  1206.     SetCtlValue(control, *amount);
  1207.  
  1208.     /* figure out the delta change */
  1209.     *amount = value - *amount;
  1210. } // p2wi_CommonScrollAction
  1211.  
  1212.  
  1213. /*
  1214. ******************************************************************************
  1215. Name:
  1216.     p2wi_VScrollActionProc
  1217. ------------------------------------------------------------------------------
  1218. Purpose:
  1219.     Determines how much to change the value of the vertical scrollbar by,
  1220.     and how much to scroll the TE record.
  1221. ------------------------------------------------------------------------------
  1222. Description:
  1223.     
  1224. ------------------------------------------------------------------------------
  1225. Parameters:
  1226.     
  1227. ------------------------------------------------------------------------------
  1228. When Used:
  1229.     Callback routine, called by toolbox
  1230. ******************************************************************************
  1231. */
  1232. pascal void p2wi_VScrollActionProc(ControlHandle control, short part)
  1233. {
  1234.     short            amount;
  1235.     p2w_WindowPtr    p2w_Window;
  1236.     TEPtr            te;
  1237.     
  1238.     if (part != 0)
  1239.     {    /* if it was actually in the control */
  1240.         p2w_Window = (p2w_WindowPtr)(*control)->contrlOwner;
  1241.         te = *p2w_Window->p2wTEHandle;
  1242.         switch (part)
  1243.         {
  1244.             case inUpButton:
  1245.             case inDownButton:        /* one line */
  1246.                 amount = 1;
  1247.                 break;
  1248.             case inPageUp:            /* one page */
  1249.             case inPageDown:
  1250.                 amount = (te->viewRect.bottom - te->viewRect.top) / te->lineHeight;
  1251.                 break;
  1252.         }
  1253.         if ((part == inDownButton) || (part == inPageDown))
  1254.             amount = -amount;        /* reverse direction if going down */
  1255.         p2wi_CommonScrollAction(control, &amount);
  1256.         if (amount != 0)
  1257.             TEScroll(0, amount * te->lineHeight, p2w_Window->p2wTEHandle);
  1258.     }
  1259. } // p2wi_VScrollActionProc
  1260.  
  1261.  
  1262. /*
  1263. ******************************************************************************
  1264. Name:
  1265.     p2wi_HScrollActionProc
  1266. ------------------------------------------------------------------------------
  1267. Purpose:
  1268.     Determines how much to change the value of the horizontal scrollbar by,
  1269.     and how much to scroll the TE record.
  1270. ------------------------------------------------------------------------------
  1271. Description:
  1272.     
  1273. ------------------------------------------------------------------------------
  1274. Parameters:
  1275.     
  1276. ------------------------------------------------------------------------------
  1277. When Used:
  1278.     Callback routine, called by toolbox
  1279. ******************************************************************************
  1280. */
  1281. pascal void p2wi_HScrollActionProc(ControlHandle control, short part)
  1282. {
  1283.     short        amount;
  1284.     p2w_WindowPtr    p2w_Window;
  1285.     TEPtr        te;
  1286.     
  1287.     if (part != 0)
  1288.     {    /* if it was actually in the control */
  1289.         p2w_Window = (p2w_WindowPtr)(*control)->contrlOwner;
  1290.         te = *p2w_Window->p2wTEHandle;
  1291.         switch (part)
  1292.         {
  1293.             case inUpButton:
  1294.             case inDownButton:        /* some pixels */
  1295.                 amount = kButtonScroll;
  1296.                 break;
  1297.             case inPageUp:            /* a whole page */
  1298.             case inPageDown:
  1299.                 amount = te->viewRect.right - te->viewRect.left;
  1300.                 break;
  1301.         }
  1302.         if ( (part == inDownButton) || (part == inPageDown) )
  1303.             amount = -amount;        /* reverse direction.. */
  1304.         p2wi_CommonScrollAction(control, &amount);
  1305.         if ( amount != 0 )
  1306.             TEScroll(amount, 0, p2w_Window->p2wTEHandle);
  1307.     }
  1308. } // p2wi_HScrollActionProc
  1309.  
  1310.  
  1311. /*---------------------------------------------------------------------*/
  1312. /*==== Standard C library fns ====*/
  1313.  
  1314. /*
  1315. ******************************************************************************
  1316. Name:
  1317.     p2w_StdCOut_BottleNeck
  1318. ------------------------------------------------------------------------------
  1319. Purpose:
  1320.     Internal Standard C output replacement common bottleneck routine..
  1321.     This is what they all call to actually display the string/character.
  1322. ------------------------------------------------------------------------------
  1323. Description:
  1324.     
  1325. ------------------------------------------------------------------------------
  1326. Parameters:
  1327.     
  1328. ------------------------------------------------------------------------------
  1329. When Used:
  1330.     
  1331. ******************************************************************************
  1332. */
  1333. static int p2w_StdCOut_BottleNeck(const FILE *stream)
  1334. {
  1335.     int        x;
  1336.     char    *OutBuf, *outp;
  1337.  
  1338.     // If the output is for standard output (stderr/stdout) then capture it into our window,
  1339.     // else send it on to the standard C file output library routine.
  1340.     if ((stream == stderr) || (stream == stdout))
  1341.     {
  1342.         // get ahold of output buffer
  1343.         OutBuf = *p2w_Stdio_OutBuf_Hdl;
  1344.         // make sure the string at least stops here! (maybe check strlen first for overflow errors?)
  1345.         *(OutBuf+kMaxStdIOBuffSize-1) = '\0';
  1346.     
  1347.         // Replace any line feeds (0x0a) with Macintosh carriage returns (0x0d)
  1348.         // This is mainly for Think C compatibility, since Think faithfully
  1349.         // literally adopted the K&R C idea (from Unix) that '\n' is really 0x0a,
  1350.         // and Apple's MPW C bends '\n' to 0x0d for better file compatibility.
  1351.  
  1352. /* Note: For now, do this in both MPW and Think C.  This will FORCE the mapping
  1353. of any LFs to CRs.  The main reason for doing this is to catch the odd times
  1354. that the source code uses either '\r', or worse, '\0x0a' to emebed returns! */
  1355. /*        if ('\n' != 0x0d) -- commented out to force issue, per above comment */
  1356.         {
  1357.             outp = OutBuf;
  1358.             while (*outp)
  1359.             {
  1360.                 if (*outp == 0x0a)
  1361.                   *outp = 0x0d;
  1362.                 outp++;
  1363.             }
  1364.         }
  1365.     
  1366.         x = p2w_AddCString(local_p2wWindow, OutBuf);    // add it into window
  1367.     }
  1368.     else
  1369.     {
  1370.         // call a real std. C library routine.  This allows output to real
  1371.         // stdio C files to pass through unmolested.
  1372. /*        x = fputs(OutBuf, stream); -- not quite the way to do it.. */
  1373.     }
  1374.  
  1375.     return x;
  1376.  
  1377. } // p2w_StdCOut_BottleNeck
  1378.  
  1379.  
  1380. /*
  1381. ******************************************************************************
  1382. Name:
  1383.     p2w_vfprintf
  1384. ------------------------------------------------------------------------------
  1385. Purpose:
  1386.     Internal common formatting handler for fprintf/printf
  1387. ------------------------------------------------------------------------------
  1388. Description:
  1389.     
  1390. ------------------------------------------------------------------------------
  1391. Parameters:
  1392.     
  1393. ------------------------------------------------------------------------------
  1394. When Used:
  1395.     
  1396. ******************************************************************************
  1397. */
  1398. static int p2w_vfprintf(FILE *stream, const char *format, va_list va_args)
  1399. {
  1400.     int        x;
  1401.     char    *outBuf;
  1402.  
  1403.     // get ahold of output buffer
  1404.     HLock(p2w_Stdio_OutBuf_Hdl);
  1405.     outBuf = *p2w_Stdio_OutBuf_Hdl;
  1406.  
  1407. #ifdef NEEDS_DEBUG
  1408. {
  1409.     // stick in a TE-length value debug into the TE record
  1410.     int daLen = (**(local_p2wWindow->p2wTEHandle)).teLength;
  1411.     sprintf(outBuf, "[%5d] ",daLen);
  1412.     x = p2w_StdCOut_BottleNeck(stream);
  1413. }
  1414. #endif NEEDS_DEBUG
  1415.  
  1416.     // use C library routine to do printf formatting of the string into buffer
  1417.     x = vsprintf(outBuf, format, va_args); // format it into a string
  1418.  
  1419.     // do the window output
  1420.     x = p2w_StdCOut_BottleNeck(stream);
  1421.  
  1422.     // cut buffer adrift again..
  1423.     HUnlock(p2w_Stdio_OutBuf_Hdl);
  1424.  
  1425.     return x;
  1426. } // p2w_vfprintf
  1427.  
  1428.  
  1429.  
  1430. int p2w_fflush(FILE *stream)
  1431. {
  1432. #pragma unused (stream)
  1433.     int        x;
  1434.  
  1435.     /* major no-op, dude */
  1436.     x = 0;
  1437.     return x;
  1438. } // p2w_fflush
  1439.  
  1440.  
  1441.  
  1442.  
  1443. int p2w_fprintf(FILE *stream, const char *format, ...)
  1444. {
  1445.     va_list    va_args;
  1446.     int        x;
  1447.  
  1448.     // use our bottleneck routine to do printf formatting
  1449.     va_start(va_args, format);
  1450.     x = p2w_vfprintf(stream, format, va_args); // format it into a string
  1451.     va_end(va_args);
  1452.  
  1453.     return x;
  1454. } // p2w_fprintf
  1455.  
  1456.  
  1457. int p2w_fputc(int theChar, FILE *stream)
  1458. {
  1459.     int        x;
  1460.     char    *outBuf;
  1461.  
  1462.     // get ahold of output buffer & make char into string
  1463.     HLock(p2w_Stdio_OutBuf_Hdl);
  1464.     outBuf = *p2w_Stdio_OutBuf_Hdl;
  1465.  
  1466.     outBuf[0] = theChar;
  1467.     outBuf[1] = '\0';
  1468.  
  1469.     x = p2w_StdCOut_BottleNeck(stream);
  1470.  
  1471.     HUnlock(p2w_Stdio_OutBuf_Hdl);
  1472.  
  1473.     return x;
  1474.  
  1475. } // p2w_fputc
  1476.  
  1477.  
  1478. int p2w_fputs(const char *theString, FILE *stream)
  1479. {
  1480.     int        x;
  1481.     char    *outBuf;
  1482.  
  1483.     // get ahold of output buffer
  1484.     HLock(p2w_Stdio_OutBuf_Hdl);
  1485.     outBuf = *p2w_Stdio_OutBuf_Hdl;
  1486.  
  1487.     // Copy string into buffer & write it
  1488.     BlockMove(theString, outBuf, kMaxStdIOBuffSize);
  1489.     x = p2w_StdCOut_BottleNeck(stream);
  1490.  
  1491.     // cut buffer adrift again..
  1492.     HUnlock(p2w_Stdio_OutBuf_Hdl);
  1493.  
  1494.     return x;
  1495. } // p2w_fputs
  1496.  
  1497.  
  1498. int p2w_printf(const char * format, ...)
  1499. {
  1500.     va_list    va_args;
  1501.     int        x;
  1502.  
  1503.     // use our bottleneck routine to do printf formatting
  1504.     va_start(va_args, format);
  1505.     x = p2w_vfprintf(stdout, format, va_args); // format it into a string
  1506.     va_end(va_args);
  1507.  
  1508.     return x;
  1509. } // p2w_printf
  1510.  
  1511.  
  1512. int p2w_putc(int theChar, FILE *stream)
  1513. {
  1514.     return p2w_fputc(theChar, stream);
  1515. } // p2w_putc
  1516.  
  1517.  
  1518. int p2w_putchar(const char theChar)
  1519. {
  1520.     return p2w_fputc(theChar, stdout);
  1521. } // p2w_putchar
  1522.  
  1523.  
  1524. int p2w_puts(const char *theString)
  1525. {
  1526.     return p2w_fputs(theString, stdout);
  1527. } // p2w_puts
  1528.